fix(bpv7): the extension editor refuses what the parser rejects - #753

`block::Flags`, `bundle::Flags` and `rfc9173::ScopeFlags` encode every
bit they hold, so a named bit carried in `unrecognised` reached the
wire as that flag while its field read false. It slipped past
`ExtensionEditor`'s `report_on_failure` refusal and `Builder::build`'s
normalisation into bytes the parser rejects, and in a BPSec scope it
left the primary block out of the IPPT/AAD the security source computed
while the emitted parameter told the receiver to include it.

All three gain `canonicalize()`, which folds each alias bit into its
named field, after `block::Type::canonicalize()`; `ScopeFlags` gains the
`From<u64>`/`From<&ScopeFlags> for u64` pair its codec now delegates to.
Every method that takes flags canonicalizes them — `Builder::with_flags`,
both `BlockBuilder::with_flags`s, `Editor::with_bundle_flags`,
`ExtensionEditor::insert`, and the BIB-HMAC-SHA2 and BCB-AES-GCM
operations' scope, with `BlockTemplate::new` as the backstop — so an
alias is refused, normalised or covered as the flag it encodes, and a
returned `Bundle` holds what its bytes hold. The IPPT and AAD builders
keep zeroing unassigned scope bits, as RFC 9173 §3.7 and §4.7.2 require,
and now say so.

Equality and hashing compare the encoding, on the three flag types and
on `block::Type`, whose ordering becomes the code order: an alias equals
its canonical form, so an aliased security scope shares one BIB with
its canonical form, and `is_canonical()` is the test that tells them
apart. Serde canonicalizes `block::Flags`, `bundle::Flags` and
`block::Type` in both directions through same-shape mirrors, so the
stored form is unchanged and always canonical; direct field writes are
not canonicalized, and the type docs say so.

BREAKING: `unrecognised` is a plain `u64` on all three types, zero when
no unrecognised bits are set (was `Option<u64>`, where `None` and
`Some(0)` meant the same): `None` becomes `0` and `Some(bits)` becomes
`bits`. Serde omits a zero field, so the shape is unchanged for every
value a parse or builder produces, except that an explicit `null` no
longer deserializes. The bpv7 tool's `inspect` and the bpa validity
filter's log follow. `block::Flags` and `bundle::Flags` implement
`Hash`, as `ScopeFlags` does; equality, hashing and `block::Type`'s
ordering go by the encoding.

Tests walk all 64 bits of each type against the RFCs' bit assignments
(RFC 9171 §4.2.3 and §4.2.4, RFC 9173 §3.3.3), each named bit decoding
to the field the RFC names it — wire round-trip, alias encoding,
canonicalization — and pin each door: the builder makes an
administrative record of the admin-bit alias and normalises its blocks,
a rebuilt or built `Bundle` matches its bytes, the extension editor
refuses the forbidden flag's alias, signing and encryption under an
aliased scope emit the folded scope and verify and decrypt, an aliased
and a canonical scope share one BIB, and an inline test pins the
`BlockTemplate::new` backstop. Every test that proves canonical form
asserts `is_canonical()` beside `==`; serde canonicalizes both ways and
refuses `null`; block types compare and order by code. The block and
bundle walks live in tests/flags.rs and the builder tests in
tests/builder.rs. `bundle inspect` lists a non-fragment bundle's flags,
which sat inside the fragment check.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>